home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / port / decsprite / regexp.h < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  6.4 KB  |  415 lines
  1. /* $Header: /private/postgres/src/port/decsprite/RCS/regexp.h,v 1.2 1991/02/02 15:21:13 sp Exp $ */
  2. /*    @(#)regexp.h    4.3    ULTRIX    3/16/88    */
  3. /*    3.0 SID #    1.3    */
  4. #define    CBRA    2
  5. #define    CCHR    4
  6. #define    CDOT    8
  7. #define    CCL    12
  8. #define    CDOL    20
  9. #define    CCEOF    22
  10. #define    CKET    24
  11. #define    CBACK    36
  12.  
  13. #define    STAR    01
  14. #define RNGE    03
  15.  
  16. #define    NBRA    9
  17.  
  18. #define PLACE(c)    ep[(c & 0377) >> 3] |= bittab[c & 07]
  19. #define ISTHERE(c)    (ep[(c & 0377) >> 3] & bittab[c & 07])
  20. #define ecmp(s1, s2, n)    (!strncmp(s1, s2, n))
  21.  
  22. static char    *braslist[NBRA];
  23. static char    *braelist[NBRA];
  24. static int    ebra;
  25. int    sed, nbra;
  26. char    *loc1, *loc2, *locs;
  27. static int    nodelim;
  28.  
  29. int    circf;
  30. static int    low;
  31. static int    size;
  32.  
  33. static char    bittab[] = { 1, 2, 4, 8, 16, 32, 64, 128 };
  34.  
  35. char *
  36. compile(instring, ep, endbuf, seof)
  37. register char *ep;
  38. char *instring, *endbuf;
  39. {
  40.     INIT    /* Dependent declarations and initializations */
  41.     register c;
  42.     register eof = seof;
  43.     char *lastep = instring;
  44.     int cclcnt;
  45.     char bracket[NBRA], *bracketp;
  46.     int closed;
  47.     int neg;
  48.     int lc;
  49.     int i, cflg;
  50.  
  51.     lastep = 0;
  52.     if((c = GETC()) == eof || c == '\n') {
  53.         if(c == '\n') {
  54.             UNGETC(c);
  55.             nodelim = 1;
  56.         }
  57.         if(*ep == 0 && !sed)
  58.             ERROR(41);
  59.         RETURN(ep);
  60.     }
  61.     bracketp = bracket;
  62.     circf = closed = nbra = ebra = 0;
  63.     if(c == '^')
  64.         circf++;
  65.     else
  66.         UNGETC(c);
  67.     while(1) {
  68.         if(ep >= endbuf)
  69.             ERROR(50);
  70.         c = GETC();
  71.         if(c != '*' && ((c != '\\') || (PEEKC() != '{')))
  72.             lastep = ep;
  73.         if(c == eof) {
  74.             *ep++ = CCEOF;
  75.             RETURN(ep);
  76.         }
  77.         switch(c) {
  78.  
  79.         case '.':
  80.             *ep++ = CDOT;
  81.             continue;
  82.  
  83.         case '\n':
  84.             if(!sed) {
  85.                 UNGETC(c);
  86.                 *ep++ = CCEOF;
  87.                 nodelim = 1;
  88.                 RETURN(ep);
  89.             }
  90.             else ERROR(36);
  91.         case '*':
  92.             if(lastep == 0 || *lastep == CBRA || *lastep == CKET)
  93.                 goto defchar;
  94.             *lastep |= STAR;
  95.             continue;
  96.  
  97.         case '$':
  98.             if(PEEKC() != eof && PEEKC() != '\n')
  99.                 goto defchar;
  100.             *ep++ = CDOL;
  101.             continue;
  102.  
  103.         case '[':
  104.             if(&ep[33] >= endbuf)
  105.                 ERROR(50);
  106.  
  107.             *ep++ = CCL;
  108.             lc = 0;
  109.             for(i = 0; i < 32; i++)
  110.                 ep[i] = 0;
  111.  
  112.             neg = 0;
  113.             if((c = GETC()) == '^') {
  114.                 neg = 1;
  115.                 c = GETC();
  116.             }
  117.  
  118.             do {
  119.                 if(c == '\0' || c == '\n')
  120.                     ERROR(49);
  121.                 if(c == '-' && lc != 0) {
  122.                     if((c = GETC()) == ']') {
  123.                         PLACE('-');
  124.                         break;
  125.                     }
  126.                     while(lc < c) {
  127.                         PLACE(lc);
  128.                         lc++;
  129.                     }
  130.                 }
  131.                 lc = c;
  132.                 PLACE(c);
  133.             } while((c = GETC()) != ']');
  134.             if(neg) {
  135.                 for(cclcnt = 0; cclcnt < 32; cclcnt++)
  136.                     ep[cclcnt] ^= -1;
  137.                 ep[0] &= 0376;
  138.             }
  139.  
  140.             ep += 32;
  141.  
  142.             continue;
  143.  
  144.         case '\\':
  145.             switch(c = GETC()) {
  146.  
  147.             case '(':
  148.                 if(nbra >= NBRA)
  149.                     ERROR(43);
  150.                 *bracketp++ = nbra;
  151.                 *ep++ = CBRA;
  152.                 *ep++ = nbra++;
  153.                 continue;
  154.  
  155.             case ')':
  156.                 if(bracketp <= bracket || ++ebra != nbra)
  157.                     ERROR(42);
  158.                 *ep++ = CKET;
  159.                 *ep++ = *--bracketp;
  160.                 closed++;
  161.                 continue;
  162.  
  163.             case '{':
  164.                 if(lastep == (char *) 0)
  165.                     goto defchar;
  166.                 *lastep |= RNGE;
  167.                 cflg = 0;
  168.             nlim:
  169.                 c = GETC();
  170.                 i = 0;
  171.                 do {
  172.                     if('0' <= c && c <= '9')
  173.                         i = 10 * i + c - '0';
  174.                     else
  175.                         ERROR(16);
  176.                 } while(((c = GETC()) != '\\') && (c != ','));
  177.                 if(i > 255)
  178.                     ERROR(11);
  179.                 *ep++ = i;
  180.                 if(c == ',') {
  181.                     if(cflg++)
  182.                         ERROR(44);
  183.                     if((c = GETC()) == '\\')
  184.                         *ep++ = 255;
  185.                     else {
  186.                         UNGETC(c);
  187.                         goto nlim;
  188.                         /* get 2'nd number */
  189.                     }
  190.                 }
  191.                 if(GETC() != '}')
  192.                     ERROR(45);
  193.                 if(!cflg)    /* one number */
  194.                     *ep++ = i;
  195.                 else if((ep[-1] & 0377) < (ep[-2] & 0377))
  196.                     ERROR(46);
  197.                 continue;
  198.  
  199.             case '\n':
  200.                 ERROR(36);
  201.  
  202.             case 'n':
  203.                 c = '\n';
  204.                 goto defchar;
  205.  
  206.             default:
  207.                 if(c >= '1' && c <= '9') {
  208.                     if((c -= '1') >= closed)
  209.                         ERROR(25);
  210.                     *ep++ = CBACK;
  211.                     *ep++ = c;
  212.                     continue;
  213.                 }
  214.             }
  215.     /* Drop through to default to use \ to turn off special chars */
  216.  
  217.         defchar:
  218.         default:
  219.             lastep = ep;
  220.             *ep++ = CCHR;
  221.             *ep++ = c;
  222.         }
  223.     }
  224.     /*NOTREACHED*/    /* DAG -- added */
  225. }
  226.  
  227. step(p1, p2)
  228. register char *p1, *p2;
  229. {
  230.     register c;
  231.  
  232.     if(circf) {
  233.         loc1 = p1;
  234.         return(advance(p1, p2));
  235.     }
  236.     /* fast check for first character */
  237.     if(*p2 == CCHR) {
  238.         c = p2[1];
  239.         do {
  240.             if(*p1 != c)
  241.                 continue;
  242.             if(advance(p1, p2)) {
  243.                 loc1 = p1;
  244.                 return(1);
  245.             }
  246.         } while(*p1++);
  247.         return(0);
  248.     }
  249.         /* regular algorithm */
  250.     do {
  251.         if(advance(p1, p2)) {
  252.             loc1 = p1;
  253.             return(1);
  254.         }
  255.     } while(*p1++);
  256.     return(0);
  257. }
  258.  
  259. advance(lp, ep)
  260. register char *lp, *ep;
  261. {
  262.     register char *curlp;
  263.     int c;
  264.     char *bbeg;
  265.     int ct;
  266.  
  267.     while(1) {
  268.         switch(*ep++) {
  269.  
  270.         case CCHR:
  271.             if(*ep++ == *lp++)
  272.                 continue;
  273.             return(0);
  274.     
  275.         case CDOT:
  276.             if(*lp++)
  277.                 continue;
  278.             return(0);
  279.     
  280.         case CDOL:
  281.             if(*lp == 0)
  282.                 continue;
  283.             return(0);
  284.     
  285.         case CCEOF:
  286.             loc2 = lp;
  287.             return(1);
  288.     
  289.         case CCL:
  290.             c = *lp++ & 0377;
  291.             if(ISTHERE(c)) {
  292.                 ep += 32;
  293.                 continue;
  294.             }
  295.             return(0);
  296.         case CBRA:
  297.             braslist[*ep++] = lp;
  298.             continue;
  299.     
  300.         case CKET:
  301.             braelist[*ep++] = lp;
  302.             continue;
  303.     
  304.         case CCHR | RNGE:
  305.             c = *ep++;
  306.             getrnge(ep);
  307.             while(low--)
  308.                 if(*lp++ != c)
  309.                     return(0);
  310.             curlp = lp;
  311.             while(size--) 
  312.                 if(*lp++ != c)
  313.                     break;
  314.             if(size < 0)
  315.                 lp++;
  316.             ep += 2;
  317.             goto star;
  318.     
  319.         case CDOT | RNGE:
  320.             getrnge(ep);
  321.             while(low--)
  322.                 if(*lp++ == '\0')
  323.                     return(0);
  324.             curlp = lp;
  325.             while(size--)
  326.                 if(*lp++ == '\0')
  327.                     break;
  328.             if(size < 0)
  329.                 lp++;
  330.             ep += 2;
  331.             goto star;
  332.     
  333.         case CCL | RNGE:
  334.             getrnge(ep + 32);
  335.             while(low--) {
  336.                 c = *lp++ & 0377;
  337.                 if(!ISTHERE(c))
  338.                     return(0);
  339.             }
  340.             curlp = lp;
  341.             while(size--) {
  342.                 c = *lp++ & 0377;
  343.                 if(!ISTHERE(c))
  344.                     break;
  345.             }
  346.             if(size < 0)
  347.                 lp++;
  348.             ep += 34;        /* 32 + 2 */
  349.             goto star;
  350.     
  351.         case CBACK:
  352.             bbeg = braslist[*ep];
  353.             ct = braelist[*ep++] - bbeg;
  354.     
  355.             if(ecmp(bbeg, lp, ct)) {
  356.                 lp += ct;
  357.                 continue;
  358.             }
  359.             return(0);
  360.     
  361.         case CBACK | STAR:
  362.             bbeg = braslist[*ep];
  363.             ct = braelist[*ep++] - bbeg;
  364.             curlp = lp;
  365.             while(ecmp(bbeg, lp, ct))
  366.                 lp += ct;
  367.     
  368.             while(lp >= curlp) {
  369.                 if(advance(lp, ep))    return(1);
  370.                 lp -= ct;
  371.             }
  372.             return(0);
  373.     
  374.     
  375.         case CDOT | STAR:
  376.             curlp = lp;
  377.             while(*lp++);
  378.             goto star;
  379.     
  380.         case CCHR | STAR:
  381.             curlp = lp;
  382.             while(*lp++ == *ep);
  383.             ep++;
  384.             goto star;
  385.     
  386.         case CCL | STAR:
  387.             curlp = lp;
  388.             do {
  389.                 c = *lp++ & 0377;
  390.             } while(ISTHERE(c));
  391.             ep += 32;
  392.             goto star;
  393.     
  394.         star:
  395.             do {
  396.                 if(--lp == locs)
  397.                     break;
  398.                 if(advance(lp, ep))
  399.                     return(1);
  400.             } while(lp > curlp);
  401.             return(0);
  402.  
  403.         }
  404.     }
  405.     /*NOTREACHED*/    /* DAG -- added */
  406. }
  407.  
  408. static
  409. getrnge(str)
  410. register char *str;
  411. {
  412.     low = *str++ & 0377;
  413.     size = (*str == 255)? 20000: (*str &0377) - low;
  414. }
  415.